//! `std::collections` 模块的测试用例
//!
//! 本文件包含对 `std::collections` 中各种数据结构的测试，
//! 包括 `Vec`, `HashMap`, `HashSet`, `BTreeMap`, `BTreeSet`, `LinkedList`, `VecDeque`, `BinaryHeap`。

#[cfg(test)]
mod tests {
    use std::collections::{
        BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque,
    };

    /// 测试 `Vec` 的基本操作
    #[test]
    fn test_vec_operations() {
        let mut vec = Vec::new();
        vec.push(1);
        vec.push(2);
        vec.push(3);

        assert_eq!(vec.len(), 3);
        assert_eq!(vec.pop(), Some(3));
        assert_eq!(vec, &[1, 2]);
    }

    /// 测试 `VecDeque` (双端队列) 的操作
    #[test]
    fn test_vec_deque_operations() {
        let mut deque = VecDeque::new();
        deque.push_back(1);
        deque.push_front(0);
        deque.push_back(2);

        assert_eq!(deque.pop_front(), Some(0));
        assert_eq!(deque.pop_back(), Some(2));
        assert_eq!(deque.len(), 1);
    }

    /// 测试 `LinkedList` (链表) 的操作
    #[test]
    fn test_linked_list_operations() {
        let mut list = LinkedList::new();
        list.push_back('a');
        list.push_back('b');
        list.push_front('z');

        assert_eq!(list.pop_front(), Some('z'));
        assert_eq!(list.pop_back(), Some('b'));
        assert_eq!(list.len(), 1);
    }

    /// 测试 `HashMap` (哈希映射) 的操作
    #[test]
    fn test_hash_map_operations() {
        let mut map = HashMap::new();
        map.insert("key1", 100);
        map.insert("key2", 200);

        assert_eq!(map.get("key1"), Some(&100));
        assert!(map.contains_key("key2"));
        assert_eq!(map.remove("key1"), Some(100));
        assert!(!map.contains_key("key1"));
    }

    /// 测试 `HashSet` (哈希集合) 的操作
    #[test]
    fn test_hash_set_operations() {
        let mut set = HashSet::new();
        set.insert(1);
        set.insert(2);
        set.insert(1); // 重复元素会被忽略

        assert_eq!(set.len(), 2);
        assert!(set.contains(&1));
        assert!(!set.contains(&3));
    }

    /// 测试 `BTreeMap` (B-树映射) 的操作
    /// `BTreeMap` 会按键排序
    #[test]
    fn test_btree_map_operations() {
        let mut map = BTreeMap::new();
        map.insert(3, "c");
        map.insert(1, "a");
        map.insert(2, "b");

        // 迭代器会按键排序
        let mut iter = map.keys();
        assert_eq!(iter.next(), Some(&1));
        assert_eq!(iter.next(), Some(&2));
        assert_eq!(iter.next(), Some(&3));
    }

    /// 测试 `BTreeSet` (B-树集合) 的操作
    /// `BTreeSet` 会按元素排序
    #[test]
    fn test_btree_set_operations() {
        let mut set = BTreeSet::new();
        set.insert(3);
        set.insert(1);
        set.insert(2);

        // 迭代器会按元素排序
        let mut iter = set.iter();
        assert_eq!(iter.next(), Some(&1));
        assert_eq!(iter.next(), Some(&2));
        assert_eq!(iter.next(), Some(&3));
    }

    /// 测试 `BinaryHeap` (二叉堆) 的操作
    /// 这是一个最大堆
    #[test]
    fn test_binary_heap_operations() {
        let mut heap = BinaryHeap::new();
        heap.push(3);
        heap.push(5);
        heap.push(1);

        assert_eq!(heap.pop(), Some(5)); // 弹出最大值
        assert_eq!(heap.pop(), Some(3));
        assert_eq!(heap.pop(), Some(1));
        assert_eq!(heap.pop(), None);
    }
}
